package test2;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import javax.print.attribute.standard.PrinterLocation;

import parser.Word;
import parser.cfg;

public class run {
	public static Var run(ArrayList<parser.Word> code,int runtimeMode) throws IOException {
		int point=0;//数组位置
		boolean jump=false;//是否跳过
		boolean QUOTE=false;
		int jump_num=0;//跳过次数
		Var left=new Var(false);//左边，在赋值和运算中非常重要，也是最终返回值
		Var right=new Var(false);
		boolean isClass=false;
		String last_u="";//上个符号
		String last1_u="";//上上个符号
		String last2_u="";//上上上个符号
		Var left1=new Var(false);
		Var left2=new Var(false);
		Var right1=new Var(false);
		for(;point<code.size();point++) {
			if(jump) {//跳过事件
				Tools.greyLang.writeLog("单词被跳过:"+code.get(point).text);
				jump_num--;
				if(jump_num==0) {
					jump=false;
				}
				continue;
			}
			parser.Word this_word=code.get(point);
			Tools.greyLang.writeLog("扫描单词:"+code.get(point).text);
			if((this_word.text.equals("true")||this_word.text.equals("false"))&&this_word.type==cfg.WORD_ATEXT) {
				//bool是按标识符储存的
				left=new Var("bool",this_word.text,false);
				continue;
			}
			if(this_word.text.equals("&")) {
				QUOTE=true;
				continue;
			}
			if(this_word.type==parser.cfg.WORD_ATEXT) {//标识符
				if(code.size()>point+1&&code.get(point+1).text.equals("(")&&isClass) {
					if(last_u.equals("+")||last_u.equals("-")) {
						isClass=false;
						right.type=right.type+right.value+"."+this_word.text+"()";
						continue;
					}
					isClass=false;
					left.type=left.type+left.value+"."+this_word.text+"()";
					continue;
				}
				if(code.size()>point+1&&code.get(point+1).text.equals(".")) {
					if(isClass) {
						if(last_u.equals("+")||last_u.equals("-")) {
							right.type=right.type+right.value+".";
							right.value=this_word.text;
							continue;
						}
						left.type=left.type+left.value+".";
						left.value=this_word.text;
						continue;
					}
					if(last_u.equals("+")||last_u.equals("-")) {
						right.value=this_word.text;
						right.type="class.";
						continue;
					}
					left.value=this_word.text;
					left.type="class.";
					continue;
				}
				if(code.size()>point+1&&!code.get(point+1).text.equals("(")&&isClass) {
					if(last_u.equals("+")||last_u.equals("-")) {
						isClass=false;
						right.type=right.type+right.value+"."+this_word.text;
						continue;
					}
					isClass=false;
					left.type=left.type+left.value+"."+this_word.text;
					continue;
				}
				if(Main.varList.containsKey(this_word.text)) {
					if(!QUOTE) {
						left.value=Main.varList.get(this_word.text).value;
						left.type=Main.varList.get(this_word.text).type;
					}else {
						left=Main.varList.get(this_word.text);
						QUOTE=false;
					}
					continue;
				}else {
					Tools.greyLang.throwErr("无效的标识符:"+this_word.text+",不存在该变量",this_word.line);
				}
			}
			if(this_word.text.equals(".")) {
				isClass=true;
				continue;
			}
			if(this_word.type==parser.cfg.WORD_TEXT) {//字符串
				left=new Var("string",this_word.text,false);
				continue;
			}
			if(this_word.type==parser.cfg.WORD_NUM) {//数字
				left=new Var("int",this_word.text,false);
				continue;
			}
			if(this_word.text.equals("==")) {
				if(right.type.equals("string")||left.type.equals("string")) {
					if(last_u.equals("-")) {
						Tools.greyLang.throwErr("string值不能进行减运算", -1);
					}
					if(last_u.equals("+")) {
						left.value=left.value+right.value;
					}
				}else {
					if(last_u.equals("+")) {
						if(right.type.equals("bool")||left.type.equals("bool")) {
							Tools.greyLang.throwErr("bool值不能进行加减运算", -1);
						}
						if(left.isClass()) {
							//到这里只能是属性
							left=classEvent.getSx(left.type);
						}
						if(right.isClass()) {
							//到这里只能是属性
							right=classEvent.getSx(left.type);
						}
						left.value=String.valueOf(Integer.parseInt(left.value)+Integer.parseInt(right.value));
					}
					if(last_u.equals("-")) {
						if(right.type.equals("bool")||left.type.equals("bool")) {
							Tools.greyLang.throwErr("bool值不能进行加减运算", -1);
						}
						if(left.isClass()) {
							//到这里只能是属性
							left=classEvent.getSx(left.type);
						}
						if(right.isClass()) {
							//到这里只能是属性
							right=classEvent.getSx(left.type);
						}
						left.value=String.valueOf(Integer.parseInt(left.value)-Integer.parseInt(right.value));
					}
				}
				
				left1.value=left.value;
				left1.type=left.type;
				last1_u="==";
				last_u="";
				continue;
			}
			if(this_word.text.equals("||")||this_word.text.equals("&&")) {
				if(last1_u.equals("==")) {
					//System.out.println(left1.value+"和"+left.value);
					if(left1.value.equals(left.value)&&left1.type.equals(left.type)) {
						left2=new Var("bool","true",false);
					}else {
						left2=new Var("bool","false",false);
					}
				}else {
					if(!last_u.equals("")) {
						Tools.greyLang.throwErr(this_word.text+"的左边不是bool", this_word.line);
					}
				}
				if(last2_u.equals("||")) {
					if(!last1_u.equals("==")) {
						right1.value=left.value;
						right1.type=left.type;
					}
					//System.out.println(left2.value+"和"+right2.value);
					if(left2.value.equals("true")||right1.value.equals("true")) {
						left2=new Var("bool","true",false);
					}else {
						left2=new Var("bool","false",false);
					}
				}
				if(last2_u.equals("&&")) {
					if(!last1_u.equals("==")) {
						right1.value=left.value;
						right1.type=left.type;
					}
					if(left2.value.equals("true")&&right1.value.equals("true")) {
						left2=new Var("bool","true",false);
					}else {
						left2=new Var("bool","false",false);
					}
				}
				last2_u=this_word.text;
				last1_u="";
				last_u="";
				continue;
			}
			if(this_word.text.equals("+")||this_word.text.equals("-")) {
				String this_left=left.value;
				if(last_u.equals("+")) {
					Tools.greyLang.writeLog("发现符号:+，"+left.value+"和"+right.value+"进行运算");
					if(right.isClass()) {
						//到这里的都是属性
						right=classEvent.getSx(right.type);
					}
					if(left.isClass()) {
						//到这里的都是属性
						left=classEvent.getSx(left.type);
					}
					if(right.type.equals("string")||left.type.equals("string")) {
						if(code.size()>point+2&&(code.get(point+2).text.equals("*")||code.get(point+2).text.equals("/"))){
							right.type="null";
						}else {
							right.type="string";
						}
						left.type="string";
						left.value=left.value+right.value;
						Tools.greyLang.writeLog(",结果为:"+left.value+",这个结果被列入左边\n");
					}else {
						if(left.type!="int")
							left.type="int";
						left.value=String.valueOf(left.getNumInt()+right.getNumInt());
						Tools.greyLang.writeLog(",结果为:"+left.value+",这个结果被列入左边\n");
					}
				}
				if(last_u.equals("-")) {
					Tools.greyLang.writeLog("发现符号:-，数字:"+left.value+"和数字"+right.value+"进行运算");
					if(right.isClass()) {
						//到这里的都是属性
						right=classEvent.getSx(right.type);
					}
					if(left.isClass()) {
						//到这里的都是属性
						left=classEvent.getSx(left.type);
					}
					if(right.type.equals("string")||left.type.equals("string")) {
						Tools.greyLang.throwErr("错误的运算符:-，无法对string类型进行减，乘，除等操作",this_word.line);
					}
					if(left.type!="int")
						left.type="int";
					left.value=String.valueOf(left.getNumInt()-right.getNumInt());
					Tools.greyLang.writeLog(",结果为:"+left.value+",这个结果被列入左边\n");
				}
				if(code.get(point+1).text.equals("(")) {
					int x=2;
					int this_jump=1;
					ArrayList<Word> aaa=new ArrayList<Word>();
					for(;point+x<code.size();x++) {
						if(code.get(point+x).text.equals("(")&&code.get(point+x).type==cfg.WORD_U) {
							this_jump++;
						}
						if(code.get(point+x).text.equals(")")&&code.get(point+x).type==cfg.WORD_U) {
							this_jump--;
							if(this_jump==0) {
								aaa.add(new Word(";",cfg.WORD_U,code.get(point-1).line));
								break;
							}else {
								aaa.add(code.get(point+x));
							}
						}else {
							aaa.add(code.get(point+x));
						}
					}
					Tools.greyLang.writeLog("发现符号:(,扫描到括号内表达式:"+Tools.greyLang.test_printWord(aaa)+"开始递归运算。。。。。。\n");
					right.value=run(aaa,cfg.MODE_VALUE).value;
					Tools.greyLang.writeLog("\n递归运算结果:"+right.value);
					jump=true;
					jump_num=x;
				}else {
					parser.Word next_word=code.get(point+1);
					if(next_word.type==parser.cfg.WORD_ATEXT) {//标识符
						if(Main.varList.containsKey(next_word.text)&&code.size()>point+2&&!code.get(point+2).text.equals(".")) {
							right.value=Main.varList.get(next_word.text).value;
							
							if(Main.varList.get(next_word.text).type.equals("string")) {
								right.type="string";
							}
							
							jump=true;
							jump_num=1;
						}else {
							if(code.size()>point+2&&code.get(point+2).text.equals(".")) {
								
							}else {
								Tools.greyLang.throwErr("无效的标识符:"+next_word.text+",不存在该变量",next_word.line);
							}
						}
					}else {
						if(next_word.type==parser.cfg.WORD_TEXT) {
							right.value=next_word.text;
							right.type="string";
						}else {
							right.value=String.valueOf(Integer.parseInt(next_word.text));
						}
						jump=true;
						jump_num=1;
					}
				}
				last_u=this_word.text;
				//Tools.greyLang.writeLog("发现符号:"+last_u+"，"+right.value+",列入右边,"+right.type);
				continue;
			}
			if(this_word.text.equals("int")||this_word.text.equals("string")||this_word.text.equals("bool")) {//1.基本数据类型变量声明
				if(code.get(point+1).type!=parser.cfg.WORD_ATEXT) {
					Tools.greyLang.throwErr("变量名不能是:"+code.get(point+1).text+",应当是一个标识符",code.get(point+1).line);
				}
				if(Main.varList.containsKey(code.get(point+1).text)) {
					Tools.greyLang.throwErr("变量名不能是:"+code.get(point+1).text+",这个变量名在之前已经被声明过",code.get(point+1).line);
				}
				if(code.get(point+1).text.equals("false")||code.get(point+1).text.equals("true")) {
					Tools.greyLang.throwErr("变量名不能是:"+code.get(point+1).text+",这是保留的变量名",code.get(point+1).line);
				}
				Main.varList.put(code.get(point+1).text,new Var(this_word.text,true));
				left=Main.varList.get(code.get(point+1).text);
				QUOTE=true;
				jump=true;
				jump_num=1;
				continue;
			}
			if(this_word.text.equals("=")) {//2.变量赋值
				if(!left.isVar) {
					Tools.greyLang.throwErr("等号的左边没有单词或左边的单词不是一个变量",this_word.line);
				}
				//扫描等号后面的所有单词直到分号，然后递归
				
				int x=1;
				int this_jump=1;
				ArrayList<Word> aaa=new ArrayList<Word>();
				for(;point+x<code.size();x++) {
					
					if(code.get(point+x).text.equals("(")&&code.get(point+x).type==cfg.WORD_U) {
						this_jump++;
					}
					if(code.get(point+x).text.equals(";")&&code.get(point+x).type==cfg.WORD_U) {
						this_jump--;
						if(this_jump==0) {
							aaa.add(code.get(point+x));
							break;
						}else {
							aaa.add(code.get(point+x));
						}
						break;
					}else {
						aaa.add(code.get(point+x));
					}
				}
				Var this_left=run(aaa,cfg.MODE_VALUE);
				if(!this_left.type.equals(left.type)) {
					Tools.greyLang.throwErr("等号的左边的数据类型和右边的数据类型不一致，"+this_left.type+"不等于"+left.type,this_word.line);
				}
				left.value=this_left.value;
				jump=true;
				jump_num=x-1;
				continue;
			}
			if(this_word.text.equals("*")||this_word.text.equals("/")) {
				String this_left;
				String this_next="0";
				if(code.get(point+1).text.equals("(")&&code.get(point+1).type==cfg.WORD_U) {
					int x=2;
					int this_jump=1;
					ArrayList<Word> aaa=new ArrayList<Word>();
					for(;point+x<code.size();x++) {
						if(code.get(point+x).text.equals("(")&&code.get(point+x).type==cfg.WORD_U) {
							this_jump++;
						}
						if(code.get(point+x).text.equals(")")&&code.get(point+x).type==cfg.WORD_U) {
							this_jump--;
							if(this_jump==0) {
								aaa.add(new Word(";",cfg.WORD_U,code.get(point-1).line));
								break;
							}else {
								aaa.add(code.get(point+x));
							}
						}else {
							aaa.add(code.get(point+x));
						}
					}
					Tools.greyLang.writeLog("发现符号:(,扫描到括号内表达式,开始递归运算。。。。。。\n");
					this_next=run(aaa,cfg.MODE_VALUE).value;
					Tools.greyLang.writeLog("\n递归运算结果:"+this_next);
					jump=true;
					jump_num=x;
				}else {
					parser.Word next_word=code.get(point+1);
					if(next_word.type==parser.cfg.WORD_ATEXT) {//标识符
						if(Main.varList.containsKey(next_word.text)) {
							this_next=Main.varList.get(next_word.text).value;
							if(Main.varList.get(next_word.text).type.equals("string")) {
								Tools.greyLang.throwErr("错误的运算符:"+this_word.text+"，无法对string类型进行减，乘，除等操作",this_word.line);
							}
							jump=true;
							jump_num=1;
						}else {
							Tools.greyLang.throwErr("无效的标识符:"+next_word.text+",不存在该变量",next_word.line);
						}
					}else {
						this_next=next_word.text;
						jump=true;
						jump_num=1;
					}
				}
				if(last_u.equals("+")||last_u.equals("-")) {
					if(this_word.text.equals("*")) {
						if(right.type.equals("string")) {
							
							Tools.greyLang.throwErr("错误的运算符:"+this_word.text+"，无法对string类型进行减，乘，除等操作",this_word.line);
						}
						this_left=String.valueOf(right.getNumInt());
						right.value=String.valueOf(Integer.parseInt(this_left)*Integer.parseInt(this_next));
						Tools.greyLang.writeLog("发现符号:*，基于:+，数字:"+this_left+"与"+Integer.parseInt(this_next)+"做运算,结果为:"+right.value+",这个结果被列入右边");
						if(right.type!="int")
							right.type="int";
					}
					if(this_word.text.equals("/")) {
						if(right.type.equals("string")) {
							Tools.greyLang.throwErr("错误的运算符:"+this_word.text+"，无法对string类型进行减，乘，除等操作",this_word.line);
						}
						this_left=String.valueOf(right.getNumInt());
						right.value=String.valueOf(Integer.parseInt(this_left)/Integer.parseInt(this_next));
						Tools.greyLang.writeLog("发现符号:/，基于:+，数字:"+this_left+"与"+Integer.parseInt(this_next)+"做运算,结果为:"+right.value+",这个结果被列入右边");
						if(right.type!="int")
							right.type="int";
					}
				}else {
					if(this_word.text.equals("*")) {
						if(left.type.equals("string")||right.type.equals("string")) {
							Tools.greyLang.throwErr("错误的运算符:"+this_word.text+"，无法对string类型进行减，乘，除等操作",this_word.line);
						}
						this_left=String.valueOf(left.getNumInt());
						left.value=String.valueOf(Integer.parseInt(this_left)*Integer.parseInt(this_next));
						Tools.greyLang.writeLog("发现符号:*，数字:"+this_left+"与"+Integer.parseInt(this_next)+"做运算,结果为:"+left.value+",这个结果被列入左边");
						if(left.type!="int")
							left.type="int";
					}
					if(this_word.text.equals("/")) {
						if(left.type.equals("string")||right.type.equals("string")) {
							Tools.greyLang.throwErr("错误的运算符:"+this_word.text+"，无法对string类型进行减，乘，除等操作",this_word.line);
						}
						this_left=String.valueOf(left.getNumInt());
						left.value=String.valueOf(Integer.parseInt(this_left)/Integer.parseInt(this_next));
						Tools.greyLang.writeLog("发现符号:*，数字:"+this_left+"与"+Integer.parseInt(this_next)+"做运算,结果为:"+left.value+",这个结果被列入左边");
						if(left.type!="int")
							left.type="int";
					}
				}
				continue;
			}
			if(this_word.text.equals("(")) {
				Tools.greyLang.writeLog("(命中");
				int x=1;
				int this_jump=1;
				boolean isClass1=left.isClass();
				ArrayList<Word> bbb=new ArrayList<Word>();
				ArrayList<ArrayList<Word>> ccc=new ArrayList<ArrayList<Word>>();
				for(;point+x<code.size();x++) {
					if(code.get(point+x).text.equals("(")&&code.get(point+x).type==cfg.WORD_U) {
						this_jump++;
					}
					if(code.get(point+x).text.equals(",")&&this_jump==1&&isClass1&&code.get(point+x).type==cfg.WORD_U) {
						bbb.add(new Word(";",cfg.WORD_U,-1));
						ccc.add(bbb);
						bbb=new ArrayList<Word>();
					}
					if(code.get(point+x).text.equals(")")&&code.get(point+x).type==cfg.WORD_U) {
						this_jump--;
						if(this_jump==0) {
							if(ccc.size()==0&&bbb.size()==0&&isClass1) {
								break;
							}
							if(bbb.size()!=0&&isClass1) {
								bbb.add(new Word(";",cfg.WORD_U,-1));
								ccc.add(bbb);
								break;
							}
							bbb.add(new Word(";",cfg.WORD_U,-1));
							break;
						}else {
							bbb.add(code.get(point+x));
						}
					}else {
						bbb.add(code.get(point+x));
					}
				}
				int y=0;
				y=2;
				Map<String,ArrayList<Word>> node=new HashMap<String,ArrayList<Word>>();
				if(code.get(point+x+1).text.equals("{")) {
					int node_jump=1;
					String this_node="main";
					node.put("main", new ArrayList<Word>());
					int this_jump_num=0;
					for(;point+x+y<code.size();y++) {
						if(this_jump_num!=0) {
							this_jump_num--;
							continue;
						}
						if(code.get(point+x+y).text.equals("{")&&code.get(point+x+y).type==cfg.WORD_U) {
							node_jump++;
						}
						if(code.get(point+x+y).text.equals("}")&&code.get(point+x+y).type==cfg.WORD_U) {
							node_jump--;
							if(node_jump==0) {
								if(point+x+y+2<code.size()&&code.get(point+x+y+1).type==cfg.WORD_ATEXT&&code.get(point+x+y+2).type==cfg.WORD_U&&code.get(point+x+y+2).text.equals("{")) {
									//new node!
									this_node=code.get(point+x+y+1).text;
									this_jump_num=2;
									node_jump=1;
									node.put(this_node, new ArrayList<Word>());
									continue;
								}
								break;
							}else {
								node.get(this_node).add(code.get(point+x+y));
							}
						}else {
							node.get(this_node).add(code.get(point+x+y));
						}
					}
				}
				//Tools.greyLang.writeLog("发现符号:(,扫描到括号内表达式:"+Tools.greyLang.test_printWord(ccc.get(0))+"开始递归运算。。。。。。\n");
				if(left.isClass()) {
					if(node.size()!=0) {
						left=classEvent.getFunc(left.type, ccc,node);
					}else {
						left=classEvent.getFunc(left.type, ccc);
					}
					
				}else {
					if(right.isClass()){
						right=classEvent.getFunc(right.type, ccc,node);
					}else {
						left.value=run(bbb,cfg.MODE_VALUE).value;
						Tools.greyLang.writeLog("\n递归运算结果:"+left.value);
					}
				}
				jump=true;
				if(node.size()!=0) {
					jump_num=x+y;
				}else {
					jump_num=x;
				}
				continue;
			}
			if(this_word.text.equals(";")) {
				if(left.isClass()) {
					//到这里只能是属性
					left=classEvent.getSx(left.type);
				}
				if(last_u.equals("+")) {
					//左边+右边=左边
					Tools.greyLang.writeLog("发现符号:;,基于:+,"+left.value+"和"+right.value+"做运算");
					if(right.type.equals("string")||left.type.equals("string")) {
						right.type="string";
						left.type="string";
						left.value=left.value+right.value;
						Tools.greyLang.writeLog(",结果为:"+left.value+",这个结果被列入左边\n");
					}else {
						if(left.type!="int")
							left.type="int";
						left.value=String.valueOf(left.getNumInt()+right.getNumInt());
						Tools.greyLang.writeLog(",结果为:"+left.value+",这个结果被列入左边\n");
					}
				}
				if(last_u.equals("-")) {
					//左边+右边=左边
					Tools.greyLang.writeLog("发现符号:;,基于:-,"+left.value+"和"+right.value+"做运算");
					if(left.type.equals("string")||right.type.equals("string")) {
						Tools.greyLang.throwErr("错误的运算符:"+this_word.text+"，无法对string类型进行减，乘，除等操作",this_word.line);
					}
					if(left.type!="int")
						left.type="int";
					left.value=String.valueOf(left.getNumInt()-right.getNumInt());
				}
				if(last1_u.equals("==")) {
					//System.out.println(left1.value+"和"+left.value);
					if(left1.value.equals(left.value)&&left1.type.equals(left.type)) {
						left=new Var("bool","true",false);
					}else {
						left=new Var("bool","false",false);
					}
				}
				if(last2_u.equals("||")) {
					//System.out.println(left2.value+"和"+left.value);
					if(last1_u.equals("==")) {
						right1.value=left.value;
						right1.type=left.type;
					}
					//System.out.println(left2.value+"和"+left.value);
					if(left2.value.equals("true")||right1.value.equals("true")) {
						left=new Var("bool","true",false);
					}else {
						left=new Var("bool","false",false);
					}
				}
				if(last2_u.equals("&&")) {
					if(last1_u.equals("==")) {
						right1.value=left.value;
						right1.type=left.type;
					}
					//System.out.println(left2.value+"和"+left.value);
					if(left2.value.equals("true")&&right1.value.equals("true")) {
						left=new Var("bool","true",false);
					}else {
						left=new Var("bool","false",false);
					}
				}
				
				if(runtimeMode==parser.cfg.MODE_VALUE) {
					Tools.greyLang.writeLog("返回值:"+left.value);
					return left;
				}
				QUOTE=false;
				left=new Var(false);
				right=new Var(false);
				last_u="";
				continue;
			}
			//Tools.greyLang.throwErr("无效的单词:"+this_word.text+"，这个单词不匹配已知的任何规则",this_word.line);
		}
		return new Var(false);
	}
}
